"use strict";
var __extends = (this && this.__extends) || (function () {
    var extendStatics = function (d, b) {
        extendStatics = Object.setPrototypeOf ||
            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
        return extendStatics(d, b);
    };
    return function (d, b) {
        if (typeof b !== "function" && b !== null)
            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
        extendStatics(d, b);
        function __() { this.constructor = d; }
        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    };
})();
/**
 * typescript中的抽象类特点:
    它是提供其他类继承的基类, 不能直接被实例化。
    用abstract关键字定义抽象类和抽象方法，抽象类中的抽象方法不包含具体实现并且必须在派生类中实现。
    abstract抽象方法只能放在抽象类里面
    抽象类和抽象方法用来定义标准
    标准:
 */
{
    var Person1 = /** @class */ (function () {
        function Person1() {
        }
        Person1.prototype.run = function () {
            console.log('其他方法可以不实现');
        };
        return Person1;
    }());
    // var a=new Person1() /* 错误的写法--抽象类不能直接被实例化*/
    // 抽象方法必须在派生类中实现:
    var Male_1 = /** @class */ (function (_super) {
        __extends(Male, _super);
        function Male() {
            return _super !== null && _super.apply(this, arguments) || this;
        }
        Male.prototype.eat = function () {
            throw new Error("Method not implemented.");
        };
        Male.prototype.run = function () {
            console.log('男生在跑');
        };
        return Male;
    }(Person1));
    var m_1 = new Male_1();
    m_1.run();
}
